Ok, I tried to make the test more rational and also divide it into more
readable sections. What do you think? What is your new score?

  The maximum score (this time I think it's reachable) is 66.
  I myself got a score of 48. (Ok, perhaps the test got a bit biased
torwards my own knowledge, but I tried to keep it as unbiased as possible;
judge by yourself :) )



POV-SDL:
-------
* Functions, macros, arrays, loops and file-IO directives are a piece of cake
  to you.
* You don't like modellers because they don't allow you to create your
  scenes algorithmically. It's a lot more interesting to find an algorithm
  to create certain effect or surface than just doing it with the mouse.
* It's not unusual that the scene files you write take several minutes to
  parse, even though the file itself only takes a few hundreds of lines.
* It sometimes happens that the scene you made takes a lot longer to parse
  than to render, even at a very high resolution and lots of antialiasing.
* You have made yourself an obfuscated signature in POV-Ray SDL in 4 lines
  or less, and you use it by default when posting to the POV-Ray news server.
* For any given identifier name you can tell by heart if it's a reserved
  keyword (ie. an illegal identifier name) or not (of course without having
  syntax highlighting to help you).
* You often debug your povray code using the text message streams.
* You've written your own include file and distributed it on the net. It has
  got some popularity.

POV features:
------------
* You have made bicubic patches by hand, by writing plain coordinates (and
  they worked as you expected).
* You have made a pov-script that creates a smooth surface with bicubic patches
  using some algorithm.
* You know the principle behind joining several bicubic patches so that they
  form a contiguous smooth surface (with no sharp edges).
* You know what is the relation between bicubic patches and bezier splines.
* You have made triangle meshes by hand, by writing plain coordinates.
* You have made a pov-script which generates triangle meshes using some
  algorithm.
* These meshes you create usually use UV-mapping.
* You know the basic principle of smoothing a mesh, ie. make a mesh of
  smooth triangles from a mesh of regular flat triangles.
* It's very easy to you to make slope maps and actually you often use
  them to make your textures.
* You use frequency, phase, octaves, omega and lambda without problems
  when creating your own textures.
* You can tell what does each one of them do.
* You understand the scattering function pictures in the media section of
  the documentation.
* The intensity multiplier curves and light fading functions in the light
  source section of the povray manual are very clear and you understand
  them perfectly (and you might use them to choose your light source
  types).
* Making good-looking radiosity images is not a problem to you.
* You could make any of the Chris Colefax's includes or macros by yourself
  if you wanted.
* You know if some special feature is already implemented in the POV-Ray 3.5
  standard include files (and thus you know you don't have to implement it
  yourself).
* You never get the "camera is inside non-hollow object" warning. If you
  ever get it, it's absolutely intentional.
* You know that a height_field has an inside and how it is defined.
* You know, without looking at the docs, how antialiasing methods 1 and 2 work
  and what's their difference. You know why method 2 gives usually a much
  better result but is slower.

Math:
----
* You have used the quadric, cubic, quartic or poly primitives.
* You have used poly objects bigger than 4th degree.
* You have calculated the polynomial for that poly object by yourself
  (instead of looking at the formula somwhere or just trying random values).
* Making isosurfaces is not a problem to you. The only problem is just
  figuring out the right function.
* You could write a torus-shaped isosurface by memory, without needing
  to look anywhere for the function.
* Even if you don't remember the torus function, you could deduce it by
  yourself, without looking it anywhere.
* You usually know when an isosurface function can be implemented as a
  poly primitive, and you could convert the function to polynomial form and
  construct the poly primitive from it (the torus function is one example
  of this).
* You know what is the "sturmian root solver" thing which is used with the
  'sturm' keyword in some objects (ie. you know the algorithm it uses) and
  why it is needed sometimes.
* You understand the matrix transformation and you can write them by hand.
* You know how to calculate the matrix from any number of consecutive
  transformations (translate, scale, rotate). (This means, for example,
  that you could write a #macro which creates the matrix transformation from
  any given set of other transformations.)
* You know how to use all the internal float, vector and string functions
  without problem. You usually use them a lot.
* You can easily calculate the camera parameters when you want to put a
  box right in front of the camera so that it completely and exactly fills
  the viewing area.

Raytracing algorithms:
---------------------
* You know the principles of raytracing. For example, you know how to calculate
  the intersection of a segment and a simple primitive like a sphere, and
  how to calculate basic lighting for this intersection point. You might even
  have written a simple raytracer some time.
* You understand why hidden surface removal, shadow testing, reflections and
  refractions are so easy to implement in raytracing and so difficult to
  implement in other rendering techniques. You know how they are implemented
  in raytracing.
* You understand why non-linear transformations are next to impossible to
  implement for any given primitive. You understand why, regardless of this,
  any type of transformation is possible for pigments and such.
* You know how CSG operations are implemented in raytracing.
* You know that 'merge' doesn't have to be a primitive CSG operation
  and can recite the equivalent sequence of intersections, unions, and
  inverses.
* You know that 'difference' isn't a primitive CSG operation and you
  know how POV represents one internally.
* You know BOTH reasons why a mesh can't be used in CSG.
* You know why refraction and media do work with meshes, even though CSG
  doesn't.
* You understand how the stochastic radiosity algorithm used by POV-Ray
  works at algorithmical level.
* You understand how photon mapping works at algorithmical level.
* You understand how dispersion works at algorithmical level.

Formats:
-------
* You have made a program which outputs a df3 file and used it in a scene.
* You know what a df3 file is and what's its format.
* You know the format of a PCM file.
* You have made one by hand.

The IRTC:
--------
* You participate in almost every IRTC contest.
* You have got to the top 20 best still images.
* You have won a price in the IRTC.

POV-Ray programming:
-------------------
* You have made a patch for povray.
* Your patch is included in MegaPov or at least it's popular.
* Your patch was included in POV-Ray 3.5.
* You have made a popular external tool for povray.
* You know which .cpp and .h files you must change to add a keyword to the
  parser.
* You can add a keyword and get it right the first time.
* You know which .cpp file contains the functionality for each aspect of
  the renderer.
* You can find a bug in the renderer source code given just a description
  of the symptoms and without using a debugger.
* You are a member of the POV-Team.


-- 
#macro N(D)#if(D>99)cylinder{M()#local D=div(D,104);M().5,2pigment{rgb M()}}
N(D)#end#end#macro M()<mod(D,13)-6mod(div(D,13)8)-3,10>#end blob{
N(11117333955)N(4254934330)N(3900569407)N(7382340)N(3358)N(970)}//  - Warp -

Post a reply to this message